namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// Base class for all Ext components. All subclasses of Component may participate in the automated
	/// Ext component lifecycle of creation, rendering and destruction which is provided by the {@link Ext.Container Container} class.
	/// Components may be added to a Container through the {@link Ext.Container#items items} config option at the time the Container is created,
	/// or they may be added dynamically via the {@link Ext.Container#add add} method.  The Component base class has built-in support for basic hide/show and enable/disable behavior.  All Components are registered with the {@link Ext.ComponentMgr} on construction so that they can be referenced at any time via
	/// {@link Ext#getCmp}, passing the {@link #id}.  All user-developed visual widgets that are required to participate in automated lifecycle and size management should subclass Component (or
	/// {@link Ext.BoxComponent} if managed box model handling is required, ie height and width management).  See the Creating new UI controls tutorial...
	/// </summary>
	/// <htmlSummary>
	/// &lt;p&gt;Base class for all Ext components. All subclasses of Component may participate in the automated
	/// Ext component lifecycle of creation, rendering and destruction which is provided by the {@link Ext.Container Container} class.
	/// Components may be added to a Container through the {@link Ext.Container#items items} config option at the time the Container is created,
	/// or they may be added dynamically via the {@link Ext.Container#add add} method.&lt;/p&gt;
	/// &lt;p&gt;The Component base class has built-in support for basic hide/show and enable/disable behavior.&lt;/p&gt;
	/// &lt;p&gt;All Components are registered with the {@link Ext.ComponentMgr} on construction so that they can be referenced at any time via
	/// {@link Ext#getCmp}, passing the {@link #id}.&lt;/p&gt;
	/// &lt;p&gt;All user-developed visual widgets that are required to participate in automated lifecycle and size management should subclass Component (or
	/// {@link Ext.BoxComponent} if managed box model handling is required, ie height and width management).&lt;/p&gt;
	/// &lt;p&gt;See the &lt;a href=&quot;http://extjs.com/learn/Tutorial:Creating_new_UI_controls&quot;&gt;Creating new UI controls&lt;/a&gt; tutorial for details on how
	/// and to either extend or augment ExtJs base classes to create custom Components.&lt;/p&gt;
	/// &lt;p&gt;Every component has a specific xtype, which is its Ext-specific type name, along with methods for checking the
	/// xtype like {@link #getXType} and {@link #isXType}. This is the list of all valid xtypes:&lt;/p&gt;
	/// &lt;pre&gt;
	/// xtype Class
	/// ------------- ------------------
	/// box {@link Ext.BoxComponent}
	/// button {@link Ext.Button}
	/// buttongroup {@link Ext.ButtonGroup}
	/// colorpalette {@link Ext.ColorPalette}
	/// component {@link Ext.Component}
	/// container {@link Ext.Container}
	/// cycle {@link Ext.CycleButton}
	/// dataview {@link Ext.DataView}
	/// datepicker {@link Ext.DatePicker}
	/// editor {@link Ext.Editor}
	/// editorgrid {@link Ext.grid.EditorGridPanel}
	/// flash {@link Ext.FlashComponent}
	/// grid {@link Ext.grid.GridPanel}
	/// listview {@link Ext.ListView}
	/// multislider {@link Ext.slider.MultiSlider}
	/// panel {@link Ext.Panel}
	/// progress {@link Ext.ProgressBar}
	/// propertygrid {@link Ext.grid.PropertyGrid}
	/// slider {@link Ext.slider.SingleSlider}
	/// spacer {@link Ext.Spacer}
	/// splitbutton {@link Ext.SplitButton}
	/// tabpanel {@link Ext.TabPanel}
	/// treepanel {@link Ext.tree.TreePanel}
	/// viewport {@link Ext.ViewPort}
	/// window {@link Ext.Window}
	///
	/// Toolbar components
	/// ---------------------------------------
	/// paging {@link Ext.PagingToolbar}
	/// toolbar {@link Ext.Toolbar}
	/// tbbutton {@link Ext.Toolbar.Button} (deprecated; use button)
	/// tbfill {@link Ext.Toolbar.Fill}
	/// tbitem {@link Ext.Toolbar.Item}
	/// tbseparator {@link Ext.Toolbar.Separator}
	/// tbspacer {@link Ext.Toolbar.Spacer}
	/// tbsplit {@link Ext.Toolbar.SplitButton} (deprecated; use splitbutton)
	/// tbtext {@link Ext.Toolbar.TextItem}
	///
	/// Menu components
	/// ---------------------------------------
	/// menu {@link Ext.menu.Menu}
	/// colormenu {@link Ext.menu.ColorMenu}
	/// datemenu {@link Ext.menu.DateMenu}
	/// menubaseitem {@link Ext.menu.BaseItem}
	/// menucheckitem {@link Ext.menu.CheckItem}
	/// menuitem {@link Ext.menu.Item}
	/// menuseparator {@link Ext.menu.Separator}
	/// menutextitem {@link Ext.menu.TextItem}
	///
	/// Form components
	/// ---------------------------------------
	/// form {@link Ext.form.FormPanel}
	/// checkbox {@link Ext.form.Checkbox}
	/// checkboxgroup {@link Ext.form.CheckboxGroup}
	/// combo {@link Ext.form.ComboBox}
	/// compositefield {@link Ext.form.CompositeField}
	/// datefield {@link Ext.form.DateField}
	/// displayfield {@link Ext.form.DisplayField}
	/// field {@link Ext.form.Field}
	/// fieldset {@link Ext.form.FieldSet}
	/// hidden {@link Ext.form.Hidden}
	/// htmleditor {@link Ext.form.HtmlEditor}
	/// label {@link Ext.form.Label}
	/// numberfield {@link Ext.form.NumberField}
	/// radio {@link Ext.form.Radio}
	/// radiogroup {@link Ext.form.RadioGroup}
	/// textarea {@link Ext.form.TextArea}
	/// textfield {@link Ext.form.TextField}
	/// timefield {@link Ext.form.TimeField}
	/// trigger {@link Ext.form.TriggerField}
	///
	/// Chart components
	/// ---------------------------------------
	/// chart {@link Ext.chart.Chart}
	/// barchart {@link Ext.chart.BarChart}
	/// cartesianchart {@link Ext.chart.CartesianChart}
	/// columnchart {@link Ext.chart.ColumnChart}
	/// linechart {@link Ext.chart.LineChart}
	/// piechart {@link Ext.chart.PieChart}
	///
	/// Store xtypes
	/// ---------------------------------------
	/// arraystore {@link Ext.data.ArrayStore}
	/// directstore {@link Ext.data.DirectStore}
	/// groupingstore {@link Ext.data.GroupingStore}
	/// jsonstore {@link Ext.data.JsonStore}
	/// simplestore {@link Ext.data.SimpleStore} (deprecated; use arraystore)
	/// store {@link Ext.data.Store}
	/// xmlstore {@link Ext.data.XmlStore}
	/// &lt;/pre&gt;
	/// </htmlSummary>
	/// <definedin>src\widgets\Component.js</definedin>
	[ScriptName("Component")]
	[ScriptNamespace("Ext")]
	[Imported()]
	public partial class Component : ext.util.Observable
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		/// <param name="config">
		/// The configuration options may be specified as either:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;an element&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is set as the internal element and its id used as the component id&lt;/p&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;a string&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is assumed to be the id of an existing element and is used as the component id&lt;/p&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;anything else&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is assumed to be a standard config object and is applied to the component&lt;/p&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		public Component(ext.Element config)
		{
		}
		
		/// <summary>Constructor</summary>
		/// <param name="config">
		/// The configuration options may be specified as either:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;an element&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is set as the internal element and its id used as the component id&lt;/p&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;a string&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is assumed to be the id of an existing element and is used as the component id&lt;/p&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;anything else&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is assumed to be a standard config object and is applied to the component&lt;/p&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		public Component(string config)
		{
		}
		
		/// <summary>Constructor</summary>
		/// <param name="config">
		/// The configuration options may be specified as either:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;an element&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is set as the internal element and its id used as the component id&lt;/p&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;a string&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is assumed to be the id of an existing element and is used as the component id&lt;/p&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;anything else&lt;/b&gt; :
		/// &lt;p class=&quot;sub-desc&quot;&gt;it is assumed to be a standard config object and is applied to the component&lt;/p&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </param>
		public Component(ext.Component_Configuration config)
		{
		}
		
		/// <summary>Constructor</summary>
		public Component()
		{
		}
		#endregion
		
		#region Fields
		/// <summary>Fires when a component is added to an Ext.Container</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("addedEventName")]
		public const string AddedEventName = "added";
		
		/// <summary>Fires after the component is disabled.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("disableEventName")]
		public const string DisableEventName = "disable";
		
		/// <summary>Fires after the component is enabled.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("enableEventName")]
		public const string EnableEventName = "enable";
		
		/// <summary>
		/// Fires before the component is shown by calling the {@link #show} method.
		/// Return false from an event handler to stop the show.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforeshowEventName")]
		public const string BeforeshowEventName = "beforeshow";
		
		/// <summary>Fires after the component is shown when calling the {@link #show} method.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("showEventName")]
		public const string ShowEventName = "show";
		
		/// <summary>
		/// Fires before the component is hidden by calling the {@link #hide} method.
		/// Return false from an event handler to stop the hide.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforehideEventName")]
		public const string BeforehideEventName = "beforehide";
		
		/// <summary>
		/// Fires after the component is hidden.
		/// Fires after the component is hidden when calling the {@link #hide} method.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("hideEventName")]
		public const string HideEventName = "hide";
		
		/// <summary>Fires when a component is removed from an Ext.Container</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("removedEventName")]
		public const string RemovedEventName = "removed";
		
		/// <summary>
		/// Fires before the component is {@link #rendered}. Return false from an
		/// event handler to stop the {@link #render}.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforerenderEventName")]
		public const string BeforerenderEventName = "beforerender";
		
		/// <summary>Fires after the component markup is {@link #rendered}.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("renderEventName")]
		public const string RenderEventName = "render";
		
		/// <summary>
		/// Fires after the component rendering is finished.  The afterrender event is fired after this Component has been {@link #rendered}, been postprocesed
		/// by any afterRender method defined for the Component, and, if {@link #stateful}, after state
		/// has been restored.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires after the component rendering is finished.&lt;/p&gt;
		/// &lt;p&gt;The afterrender event is fired after this Component has been {@link #rendered}, been postprocesed
		/// by any afterRender method defined for the Component, and, if {@link #stateful}, after state
		/// has been restored.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("afterrenderEventName")]
		public const string AfterrenderEventName = "afterrender";
		
		/// <summary>Fires before the component is {@link #destroy}ed. Return false from an event handler to stop the {@link #destroy}.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforedestroyEventName")]
		public const string BeforedestroyEventName = "beforedestroy";
		
		/// <summary>Fires after the component is {@link #destroy}ed.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("destroyEventName")]
		public const string DestroyEventName = "destroy";
		
		/// <summary>Fires before the state of the component is restored. Return false from an event handler to stop the restore.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforestaterestoreEventName")]
		public const string BeforestaterestoreEventName = "beforestaterestore";
		
		/// <summary>Fires after the state of the component is restored.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("staterestoreEventName")]
		public const string StaterestoreEventName = "staterestore";
		
		/// <summary>Fires before the state of the component is saved to the configured state provider. Return false to stop the save.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforestatesaveEventName")]
		public const string BeforestatesaveEventName = "beforestatesave";
		
		/// <summary>Fires after the state of the component is saved to the configured state provider.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("statesaveEventName")]
		public const string StatesaveEventName = "statesave";
		
		/// <summary>The label text to display next to this Component (defaults to &apos;&apos;).</summary>
		/// <htmlSummary>
		/// &lt;p&gt;The label text to display next to this Component (defaults to &apos;&apos;).&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: this config is only used when this Component is rendered by a Container which
		/// has been configured to use the &lt;b&gt;{@link Ext.layout.FormLayout FormLayout}&lt;/b&gt; layout manager (e.g.
		/// {@link Ext.form.FormPanel} or specifying &lt;tt&gt;layout:&apos;form&apos;&lt;/tt&gt;).&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;Also see &lt;tt&gt;{@link #hideLabel}&lt;/tt&gt; and
		/// {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl}.&lt;/p&gt;
		/// Example use:&lt;pre&gt;&lt;code&gt;
		/// new Ext.FormPanel({
		/// height: 100,
		/// renderTo: Ext.getBody(),
		/// items: [{
		/// xtype: &apos;textfield&apos;,
		/// fieldLabel: &apos;Name&apos;
		/// }]
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("fieldLabel")]
		public string FieldLabel;
		
		/// <summary>
		/// A CSS style specification string to apply directly to this field&apos;s
		/// label. Defaults to the container&apos;s labelStyle value if set (e.g.,
		/// {@link Ext.layout.FormLayout#labelStyle} , or &apos;&apos;).
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;A CSS style specification string to apply directly to this field&apos;s
		/// label. Defaults to the container&apos;s labelStyle value if set (e.g.,
		/// &lt;tt&gt;{@link Ext.layout.FormLayout#labelStyle}&lt;/tt&gt; , or &apos;&apos;).&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: see the note for &lt;code&gt;{@link #clearCls}&lt;/code&gt;.&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;Also see &lt;code&gt;{@link #hideLabel}&lt;/code&gt; and
		/// &lt;code&gt;{@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl}.&lt;/code&gt;&lt;/p&gt;
		/// Example use:&lt;pre&gt;&lt;code&gt;
		/// new Ext.FormPanel({
		/// height: 100,
		/// renderTo: Ext.getBody(),
		/// items: [{
		/// xtype: &apos;textfield&apos;,
		/// fieldLabel: &apos;Name&apos;,
		/// labelStyle: &apos;font-weight:bold;&apos;
		/// }]
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("labelStyle")]
		public string LabelStyle;
		
		/// <summary>
		/// The separator to display after the text of each
		/// {@link #fieldLabel}. This property may be configured at various levels.
		/// The order of precedence is:
		///   field / component level  container level  {@link Ext.layout.FormLayout#labelSeparator layout level} (defaults to colon &apos;:&apos;)   
		/// To display no separator for this field&apos;s label specify empty string &apos;&apos;.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;The separator to display after the text of each
		/// &lt;tt&gt;{@link #fieldLabel}&lt;/tt&gt;. This property may be configured at various levels.
		/// The order of precedence is:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;field / component level&lt;/li&gt;
		/// &lt;li&gt;container level&lt;/li&gt;
		/// &lt;li&gt;{@link Ext.layout.FormLayout#labelSeparator layout level} (defaults to colon &lt;tt&gt;&apos;:&apos;&lt;/tt&gt;)&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// To display no separator for this field&apos;s label specify empty string &apos;&apos;.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: see the note for &lt;tt&gt;{@link #clearCls}&lt;/tt&gt;.&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;Also see &lt;tt&gt;{@link #hideLabel}&lt;/tt&gt; and
		/// {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl}.&lt;/p&gt;
		/// Example use:&lt;pre&gt;&lt;code&gt;
		/// new Ext.FormPanel({
		/// height: 100,
		/// renderTo: Ext.getBody(),
		/// layoutConfig: {
		/// labelSeparator: &apos;~&apos; // layout config has lowest priority (defaults to &apos;:&apos;)
		/// },
		/// {@link Ext.layout.FormLayout#labelSeparator labelSeparator}: &apos;&gt;&gt;&apos;, // config at container level
		/// items: [{
		/// xtype: &apos;textfield&apos;,
		/// fieldLabel: &apos;Field 1&apos;,
		/// labelSeparator: &apos;...&apos; // field/component level config supersedes others
		/// },{
		/// xtype: &apos;textfield&apos;,
		/// fieldLabel: &apos;Field 2&apos; // labelSeparator will be &apos;=&apos;
		/// }]
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("labelSeparator")]
		public string LabelSeparator;
		
		/// <summary>
		/// true to completely hide the label element
		/// ({@link #fieldLabel label} and {@link #labelSeparator separator}). Defaults to false.
		/// By default, even if you do not specify a {@link #fieldLabel} the space will still be
		/// reserved so that the field will line up with other fields that do have labels.
		/// Setting this to true will cause the field to not reserve that space.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;&lt;tt&gt;true&lt;/tt&gt; to completely hide the label element
		/// ({@link #fieldLabel label} and {@link #labelSeparator separator}). Defaults to &lt;tt&gt;false&lt;/tt&gt;.
		/// By default, even if you do not specify a &lt;tt&gt;{@link #fieldLabel}&lt;/tt&gt; the space will still be
		/// reserved so that the field will line up with other fields that do have labels.
		/// Setting this to &lt;tt&gt;true&lt;/tt&gt; will cause the field to not reserve that space.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: see the note for &lt;tt&gt;{@link #clearCls}&lt;/tt&gt;.&lt;/p&gt;&lt;br&gt;
		/// Example use:&lt;pre&gt;&lt;code&gt;
		/// new Ext.FormPanel({
		/// height: 100,
		/// renderTo: Ext.getBody(),
		/// items: [{
		/// xtype: &apos;textfield&apos;
		/// hideLabel: true
		/// }]
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("hideLabel")]
		public bool HideLabel;
		
		/// <summary>
		/// The CSS class used to to apply to the special clearing div rendered
		/// directly after each form field wrapper to provide field clearing (defaults to
		/// &apos;x-form-clear-left&apos;).
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;The CSS class used to to apply to the special clearing div rendered
		/// directly after each form field wrapper to provide field clearing (defaults to
		/// &lt;tt&gt;&apos;x-form-clear-left&apos;&lt;/tt&gt;).&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: this config is only used when this Component is rendered by a Container
		/// which has been configured to use the &lt;b&gt;{@link Ext.layout.FormLayout FormLayout}&lt;/b&gt; layout
		/// manager (e.g. {@link Ext.form.FormPanel} or specifying &lt;tt&gt;layout:&apos;form&apos;&lt;/tt&gt;) and either a
		/// &lt;tt&gt;{@link #fieldLabel}&lt;/tt&gt; is specified or &lt;tt&gt;isFormField=true&lt;/tt&gt; is specified.&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;See {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl} also.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("clearCls")]
		public string ClearCls;
		
		/// <summary>
		/// Note: this config is only used when this Component is rendered by a Container which
		/// has been configured to use the {@link Ext.layout.FormLayout FormLayout} layout manager (e.g.
		/// {@link Ext.form.FormPanel} or specifying layout:&apos;form&apos;).
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: this config is only used when this Component is rendered by a Container which
		/// has been configured to use the &lt;b&gt;{@link Ext.layout.FormLayout FormLayout}&lt;/b&gt; layout manager (e.g.
		/// {@link Ext.form.FormPanel} or specifying &lt;tt&gt;layout:&apos;form&apos;&lt;/tt&gt;).&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;An additional CSS class to apply to the div wrapping the form item
		/// element of this field. If supplied, &lt;tt&gt;itemCls&lt;/tt&gt; at the &lt;b&gt;field&lt;/b&gt; level will override
		/// the default &lt;tt&gt;itemCls&lt;/tt&gt; supplied at the &lt;b&gt;container&lt;/b&gt; level. The value specified for
		/// &lt;tt&gt;itemCls&lt;/tt&gt; will be added to the default class (&lt;tt&gt;&apos;x-form-item&apos;&lt;/tt&gt;).&lt;/p&gt;
		/// &lt;p&gt;Since it is applied to the item wrapper (see
		/// {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl}), it allows
		/// you to write standard CSS rules that can apply to the field, the label (if specified), or
		/// any other element within the markup for the field.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: see the note for &lt;tt&gt;{@link #fieldLabel}&lt;/tt&gt;.&lt;/p&gt;&lt;br&gt;
		/// Example use:&lt;pre&gt;&lt;code&gt;
		/// // Apply a style to the field&amp;#39;s label:
		/// &amp;lt;style&gt;
		/// .required .x-form-item-label {font-weight:bold;color:red;}
		/// &amp;lt;/style&gt;
		///
		/// new Ext.FormPanel({
		/// height: 100,
		/// renderTo: Ext.getBody(),
		/// items: [{
		/// xtype: &apos;textfield&apos;,
		/// fieldLabel: &apos;Name&apos;,
		/// itemCls: &apos;required&apos; //this label will be styled
		/// },{
		/// xtype: &apos;textfield&apos;,
		/// fieldLabel: &apos;Favorite Color&apos;
		/// }]
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("itemCls")]
		public string ItemCls;
		
		/// <summary>
		/// The unique id of this component (defaults to an {@link #getId auto-assigned id}).
		/// You should assign an id if you need to be able to access the component later and you do
		/// not have an object reference available (e.g., using {@link Ext}.{@link Ext#getCmp getCmp}).  Note that this id will also be used as the element id for the containing HTML element
		/// that is rendered to the page for this component. This allows you to write id-based CSS
		/// rules to style the specific instance of this component uniquely, and also to select
		/// sub-elements using this component&apos;s id as the parent.  Note: to avoid complications imposed by a unique id also see
		/// {@link #itemId} and {@link #ref}.  Note: to access the container of an item see {@link #ownerCt}.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;The &lt;b&gt;unique&lt;/b&gt; id of this component (defaults to an {@link #getId auto-assigned id}).
		/// You should assign an id if you need to be able to access the component later and you do
		/// not have an object reference available (e.g., using {@link Ext}.{@link Ext#getCmp getCmp}).&lt;/p&gt;
		/// &lt;p&gt;Note that this id will also be used as the element id for the containing HTML element
		/// that is rendered to the page for this component. This allows you to write id-based CSS
		/// rules to style the specific instance of this component uniquely, and also to select
		/// sub-elements using this component&apos;s id as the parent.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: to avoid complications imposed by a unique &lt;tt&gt;id&lt;/tt&gt; also see
		/// &lt;code&gt;{@link #itemId}&lt;/code&gt; and &lt;code&gt;{@link #ref}&lt;/code&gt;.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: to access the container of an item see &lt;code&gt;{@link #ownerCt}&lt;/code&gt;.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("id")]
		public string Id;
		
		/// <summary>
		/// An itemId can be used as an alternative way to get a reference to a component
		/// when no object reference is available. Instead of using an {@link #id} with
		/// {@link Ext}.{@link Ext#getCmp getCmp}, use itemId with
		/// {@link Ext.Container}.{@link Ext.Container#getComponent getComponent} which will retrieve
		/// itemId&apos;s or {@link #id}&apos;s. Since itemId&apos;s are an index to the
		/// container&apos;s internal MixedCollection, the itemId is scoped locally to the container --
		/// avoiding potential conflicts with {@link Ext.ComponentMgr} which requires a unique{@link #id}.  
		/// var c = new Ext.Panel({ //
		/// {@link Ext.BoxComponent#height height}: 300,
		/// {@link #renderTo}: document.body,
		/// {@link Ext.Container#layout layout}: &apos;auto&apos;,
		/// {@link Ext.Container#items items}: [
		/// {
		/// itemId: &apos;p1&apos;,
		/// {@link Ext.Panel#title title}: &apos;Panel 1&apos;,
		/// {@link Ext.BoxComponent#height height}: 150
		/// },
		/// {
		/// itemId: &apos;p2&apos;,
		/// {@link Ext.Panel#title title}: &apos;Panel 2&apos;,
		/// {@link Ext.BoxComponent#height height}: 150
		/// }
		/// ]
		/// })
		/// p1 = c.{@link...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An &lt;tt&gt;itemId&lt;/tt&gt; can be used as an alternative way to get a reference to a component
		/// when no object reference is available. Instead of using an &lt;code&gt;{@link #id}&lt;/code&gt; with
		/// {@link Ext}.{@link Ext#getCmp getCmp}, use &lt;code&gt;itemId&lt;/code&gt; with
		/// {@link Ext.Container}.{@link Ext.Container#getComponent getComponent} which will retrieve
		/// &lt;code&gt;itemId&lt;/code&gt;&apos;s or &lt;tt&gt;{@link #id}&lt;/tt&gt;&apos;s. Since &lt;code&gt;itemId&lt;/code&gt;&apos;s are an index to the
		/// container&apos;s internal MixedCollection, the &lt;code&gt;itemId&lt;/code&gt; is scoped locally to the container --
		/// avoiding potential conflicts with {@link Ext.ComponentMgr} which requires a &lt;b&gt;unique&lt;/b&gt;
		/// &lt;code&gt;{@link #id}&lt;/code&gt;.&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var c = new Ext.Panel({ //
		/// {@link Ext.BoxComponent#height height}: 300,
		/// {@link #renderTo}: document.body,
		/// {@link Ext.Container#layout layout}: &apos;auto&apos;,
		/// {@link Ext.Container#items items}: [
		/// {
		/// itemId: &apos;p1&apos;,
		/// {@link Ext.Panel#title title}: &apos;Panel 1&apos;,
		/// {@link Ext.BoxComponent#height height}: 150
		/// },
		/// {
		/// itemId: &apos;p2&apos;,
		/// {@link Ext.Panel#title title}: &apos;Panel 2&apos;,
		/// {@link Ext.BoxComponent#height height}: 150
		/// }
		/// ]
		/// })
		/// p1 = c.{@link Ext.Container#getComponent getComponent}(&apos;p1&apos;); // not the same as {@link Ext#getCmp Ext.getCmp()}
		/// p2 = p1.{@link #ownerCt}.{@link Ext.Container#getComponent getComponent}(&apos;p2&apos;); // reference via a sibling
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;Also see &lt;tt&gt;{@link #id}&lt;/tt&gt; and &lt;code&gt;{@link #ref}&lt;/code&gt;.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: to access the container of an item see &lt;tt&gt;{@link #ownerCt}&lt;/tt&gt;.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("itemId")]
		public string ItemId;
		
		/// <summary>
		/// The registered xtype to create. This config option is not used when passing
		/// a config object into a constructor. This config option is used only when
		/// lazy instantiation is being used, and a child item of a Container is being
		/// specified not as a fully instantiated Component, but as a Component config
		/// object. The xtype will be looked up at render time up to determine what
		/// type of child Component to create.
		/// </summary>
		/// <htmlSummary>
		/// The registered &lt;tt&gt;xtype&lt;/tt&gt; to create. This config option is not used when passing
		/// a config object into a constructor. This config option is used only when
		/// lazy instantiation is being used, and a child item of a Container is being
		/// specified not as a fully instantiated Component, but as a &lt;i&gt;Component config
		/// object&lt;/i&gt;. The &lt;tt&gt;xtype&lt;/tt&gt; will be looked up at render time up to determine what
		/// type of child Component to create.&lt;br&gt;&lt;br&gt;
		/// The predefined xtypes are listed {@link Ext.Component here}.
		/// &lt;br&gt;&lt;br&gt;
		/// If you subclass Components to create your own Components, you may register
		/// them using {@link Ext.ComponentMgr#registerType} in order to be able to
		/// take advantage of lazy instantiation and rendering.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("xtype")]
		public string Xtype;
		
		/// <summary>
		/// The registered ptype to create. This config option is not used when passing
		/// a config object into a constructor. This config option is used only when
		/// lazy instantiation is being used, and a Plugin is being
		/// specified not as a fully instantiated Component, but as a Component config
		/// object. The ptype will be looked up at render time up to determine what
		/// type of Plugin to create.
		/// </summary>
		/// <htmlSummary>
		/// The registered &lt;tt&gt;ptype&lt;/tt&gt; to create. This config option is not used when passing
		/// a config object into a constructor. This config option is used only when
		/// lazy instantiation is being used, and a Plugin is being
		/// specified not as a fully instantiated Component, but as a &lt;i&gt;Component config
		/// object&lt;/i&gt;. The &lt;tt&gt;ptype&lt;/tt&gt; will be looked up at render time up to determine what
		/// type of Plugin to create.&lt;br&gt;&lt;br&gt;
		/// If you create your own Plugins, you may register them using
		/// {@link Ext.ComponentMgr#registerPlugin} in order to be able to
		/// take advantage of lazy instantiation and rendering.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("ptype")]
		public string Ptype;
		
		/// <summary>
		/// An optional extra CSS class that will be added to this component&apos;s Element (defaults to &apos;&apos;). This can be
		/// useful for adding customized styles to the component or any of its children using standard CSS rules.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("cls")]
		public string Cls;
		
		/// <summary>
		/// An optional extra CSS class that will be added to this component&apos;s Element when the mouse moves
		/// over the Element, and removed when the mouse moves out. (defaults to &apos;&apos;). This can be
		/// useful for adding customized &apos;active&apos; or &apos;hover&apos; styles to the component or any of its children using standard CSS rules.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("overCls")]
		public string OverCls;
		
		/// <summary>
		/// A custom style specification to be applied to this component&apos;s Element. Should be a valid argument to
		/// {@link Ext.Element#applyStyles}.
		/// 
		/// new Ext.Panel({
		/// title: &apos;Some Title&apos;,
		/// renderTo: Ext.getBody(),
		/// width: 400, height: 300,
		/// layout: &apos;form&apos;,
		/// items: [{
		/// xtype: &apos;textarea&apos;,
		/// style: {
		/// width: &apos;95%&apos;,
		/// marginBottom: &apos;10px&apos;
		/// }
		/// },
		/// new Ext.Button({
		/// text: &apos;Send&apos;,
		/// minWidth: &apos;100&apos;,
		/// style: {
		/// marginBottom: &apos;10px&apos;
		/// }
		/// })
		/// ]
		/// });
		/// </summary>
		/// <htmlSummary>
		/// A custom style specification to be applied to this component&apos;s Element. Should be a valid argument to
		/// {@link Ext.Element#applyStyles}.
		/// &lt;pre&gt;&lt;code&gt;
		/// new Ext.Panel({
		/// title: &apos;Some Title&apos;,
		/// renderTo: Ext.getBody(),
		/// width: 400, height: 300,
		/// layout: &apos;form&apos;,
		/// items: [{
		/// xtype: &apos;textarea&apos;,
		/// style: {
		/// width: &apos;95%&apos;,
		/// marginBottom: &apos;10px&apos;
		/// }
		/// },
		/// new Ext.Button({
		/// text: &apos;Send&apos;,
		/// minWidth: &apos;100&apos;,
		/// style: {
		/// marginBottom: &apos;10px&apos;
		/// }
		/// })
		/// ]
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("style")]
		public string Style;
		
		/// <summary>
		/// An optional extra CSS class that will be added to this component&apos;s container. This can be useful for
		/// adding customized styles to the container or any of its children using standard CSS rules. See
		/// {@link Ext.layout.ContainerLayout}.{@link Ext.layout.ContainerLayout#extraCls extraCls} also.  Note: ctCls defaults to &apos;&apos; except for the following class
		/// which assigns a value by default:
		///   {@link Ext.layout.Box Box Layout} : &apos;x-box-layout-ct&apos;   
		/// To configure the above Class with an extra CSS class append to the default. For example,
		/// for BoxLayout (Hbox and Vbox): 
		/// ctCls: &apos;x-box-layout-ct custom-class&apos;
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An optional extra CSS class that will be added to this component&apos;s container. This can be useful for
		/// adding customized styles to the container or any of its children using standard CSS rules. See
		/// {@link Ext.layout.ContainerLayout}.{@link Ext.layout.ContainerLayout#extraCls extraCls} also.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: &lt;tt&gt;ctCls&lt;/tt&gt; defaults to &lt;tt&gt;&apos;&apos;&lt;/tt&gt; except for the following class
		/// which assigns a value by default:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;{@link Ext.layout.Box Box Layout} : &lt;tt&gt;&apos;x-box-layout-ct&apos;&lt;/tt&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// To configure the above Class with an extra CSS class append to the default. For example,
		/// for BoxLayout (Hbox and Vbox):&lt;pre&gt;&lt;code&gt;
		/// ctCls: &apos;x-box-layout-ct custom-class&apos;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("ctCls")]
		public string CtCls;
		
		/// <summary>Render this component disabled (default is false).</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("disabled")]
		public bool Disabled;
		
		/// <summary>
		/// Render this component hidden (default is false). If true, the
		/// {@link #hide} method will be called internally.
		/// </summary>
		/// <htmlSummary>
		/// Render this component hidden (default is false). If &lt;tt&gt;true&lt;/tt&gt;, the
		/// {@link #hide} method will be called internally.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("hidden")]
		public bool Hidden;
		
		/// <summary>
		/// An object or array of objects that will provide custom functionality for this component. The only
		/// requirement for a valid plugin is that it contain an init method that accepts a reference of type Ext.Component.
		/// When a component is created, if any plugins are available, the component will call the init method on each
		/// plugin, passing a reference to itself. Each plugin can then call methods or respond to events on the
		/// component as needed to provide its functionality.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("plugins")]
		public ext.auto.System_Object_Or_System_Array Plugins;
		
		/// <summary>
		/// Specify the id of the element, a DOM element or an existing Element corresponding to a DIV
		/// that is already present in the document that specifies some structural markup for this
		/// component.    Description :   When applyTo is used, constituent parts of the component can also be specified
		/// by id or CSS class name within the main element, and the component being created may attempt
		/// to create its subcomponents from that markup if applicable.    Notes :   When using this config, a call to render() is not required.  If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target
		/// element&apos;s parent node will automatically be used as the component&apos;s container.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Specify the id of the element, a DOM element or an existing Element corresponding to a DIV
		/// that is already present in the document that specifies some structural markup for this
		/// component.&lt;/p&gt;&lt;div&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;Description&lt;/b&gt; : &lt;ul&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;When &lt;tt&gt;applyTo&lt;/tt&gt; is used, constituent parts of the component can also be specified
		/// by id or CSS class name within the main element, and the component being created may attempt
		/// to create its subcomponents from that markup if applicable.&lt;/div&gt;
		/// &lt;/ul&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;Notes&lt;/b&gt; : &lt;ul&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;When using this config, a call to render() is not required.&lt;/div&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;If applyTo is specified, any value passed for {@link #renderTo} will be ignored and the target
		/// element&apos;s parent node will automatically be used as the component&apos;s container.&lt;/div&gt;
		/// &lt;/ul&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("applyTo")]
		public object ApplyTo;
		
		/// <summary>
		/// Specify the id of the element, a DOM element or an existing Element that this component
		/// will be rendered into.    Notes :   Do not use this option if the Component is to be a child item of
		/// a {@link Ext.Container Container}. It is the responsibility of the
		/// {@link Ext.Container Container}&apos;s {@link Ext.Container#layout layout manager}
		/// to render and manage its child items.  When using this config, a call to render() is not required.      See {@link #render} also.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Specify the id of the element, a DOM element or an existing Element that this component
		/// will be rendered into.&lt;/p&gt;&lt;div&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;Notes&lt;/b&gt; : &lt;ul&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;Do &lt;u&gt;not&lt;/u&gt; use this option if the Component is to be a child item of
		/// a {@link Ext.Container Container}. It is the responsibility of the
		/// {@link Ext.Container Container}&apos;s {@link Ext.Container#layout layout manager}
		/// to render and manage its child items.&lt;/div&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;When using this config, a call to render() is not required.&lt;/div&gt;
		/// &lt;/ul&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;p&gt;See &lt;tt&gt;{@link #render}&lt;/tt&gt; also.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("renderTo")]
		public object RenderTo;
		
		/// <summary>
		/// A flag which causes the Component to attempt to restore the state of
		/// internal properties from a saved state on startup. The component must have
		/// either a {@link #stateId} or {@link #id} assigned
		/// for state to be managed. Auto-generated ids are not guaranteed to be stable
		/// across page loads and cannot be relied upon to save and restore the same
		/// state for a component.  For state saving to work, the state manager&apos;s provider must have been
		/// set to an implementation of {@link Ext.state.Provider} which overrides the
		/// {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get}
		/// methods to save and recall name/value pairs. A built-in implementation,
		/// {@link Ext.state.CookieProvider} is available.  To set the state provider for the current page:  
		/// Ext.state.Manager.setProvider(new Ext.state.CookieProvider({
		/// expires: new Date(new Date().getTime()+(1000*60*60*24*7)), //7 days from now
		/// }));
		///  A stateful Component attempts to save state when one of the events
		/// listed in the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;A flag which causes the Component to attempt to restore the state of
		/// internal properties from a saved state on startup. The component must have
		/// either a &lt;code&gt;{@link #stateId}&lt;/code&gt; or &lt;code&gt;{@link #id}&lt;/code&gt; assigned
		/// for state to be managed. Auto-generated ids are not guaranteed to be stable
		/// across page loads and cannot be relied upon to save and restore the same
		/// state for a component.&lt;p&gt;
		/// &lt;p&gt;For state saving to work, the state manager&apos;s provider must have been
		/// set to an implementation of {@link Ext.state.Provider} which overrides the
		/// {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get}
		/// methods to save and recall name/value pairs. A built-in implementation,
		/// {@link Ext.state.CookieProvider} is available.&lt;/p&gt;
		/// &lt;p&gt;To set the state provider for the current page:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// Ext.state.Manager.setProvider(new Ext.state.CookieProvider({
		/// expires: new Date(new Date().getTime()+(1000*60*60*24*7)), //7 days from now
		/// }));
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;A stateful Component attempts to save state when one of the events
		/// listed in the &lt;code&gt;{@link #stateEvents}&lt;/code&gt; configuration fires.&lt;/p&gt;
		/// &lt;p&gt;To save state, a stateful Component first serializes its state by
		/// calling &lt;b&gt;&lt;code&gt;getState&lt;/code&gt;&lt;/b&gt;. By default, this function does
		/// nothing. The developer must provide an implementation which returns an
		/// object hash which represents the Component&apos;s restorable state.&lt;/p&gt;
		/// &lt;p&gt;The value yielded by getState is passed to {@link Ext.state.Manager#set}
		/// which uses the configured {@link Ext.state.Provider} to save the object
		/// keyed by the Component&apos;s &lt;code&gt;{@link stateId}&lt;/code&gt;, or, if that is not
		/// specified, its &lt;code&gt;{@link #id}&lt;/code&gt;.&lt;/p&gt;
		/// &lt;p&gt;During construction, a stateful Component attempts to &lt;i&gt;restore&lt;/i&gt;
		/// its state by calling {@link Ext.state.Manager#get} passing the
		/// &lt;code&gt;{@link #stateId}&lt;/code&gt;, or, if that is not specified, the
		/// &lt;code&gt;{@link #id}&lt;/code&gt;.&lt;/p&gt;
		/// &lt;p&gt;The resulting object is passed to &lt;b&gt;&lt;code&gt;applyState&lt;/code&gt;&lt;/b&gt;.
		/// The default implementation of &lt;code&gt;applyState&lt;/code&gt; simply copies
		/// properties into the object, but a developer may override this to support
		/// more behaviour.&lt;/p&gt;
		/// &lt;p&gt;You can perform extra processing on state save and restore by attaching
		/// handlers to the {@link #beforestaterestore}, {@link #staterestore},
		/// {@link #beforestatesave} and {@link #statesave} events.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("stateful")]
		public bool Stateful;
		
		/// <summary>
		/// The unique id for this component to use for state management purposes
		/// (defaults to the component id if one was set, otherwise null if the
		/// component is using a generated id).
		/// See {@link #stateful} for an explanation of saving and
		/// restoring Component state.
		/// </summary>
		/// <htmlSummary>
		/// The unique id for this component to use for state management purposes
		/// (defaults to the component id if one was set, otherwise null if the
		/// component is using a generated id).
		/// &lt;p&gt;See &lt;code&gt;{@link #stateful}&lt;/code&gt; for an explanation of saving and
		/// restoring Component state.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("stateId")]
		public string StateId;
		
		/// <summary>
		/// An array of events that, when fired, should trigger this component to
		/// save its state (defaults to none). stateEvents may be any type
		/// of event supported by this component, including browser or custom events
		/// (e.g., [&apos;click&apos;, &apos;customerchange&apos;]).  See {@link #stateful} for an explanation of saving and
		/// restoring Component state.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An array of events that, when fired, should trigger this component to
		/// save its state (defaults to none). &lt;code&gt;stateEvents&lt;/code&gt; may be any type
		/// of event supported by this component, including browser or custom events
		/// (e.g., &lt;tt&gt;[&apos;click&apos;, &apos;customerchange&apos;]&lt;/tt&gt;).&lt;/p&gt;
		/// &lt;p&gt;See &lt;code&gt;{@link #stateful}&lt;/code&gt; for an explanation of saving and
		/// restoring Component state.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("stateEvents")]
		public System.Array StateEvents;
		
		/// <summary>
		/// A tag name or {@link Ext.DomHelper DomHelper} spec used to create the {@link #getEl Element} which will
		/// encapsulate this Component.  You do not normally need to specify this. For the base classes {@link Ext.Component}, {@link Ext.BoxComponent},
		/// and {@link Ext.Container}, this defaults to &apos;div&apos;. The more complex Ext classes use a more complex
		/// DOM structure created by their own onRender methods.  This is intended to allow the developer to create application-specific utility Components encapsulated by
		/// different DOM elements. Example usage:  
		/// {
		/// xtype: &apos;box&apos;,
		/// autoEl: {
		/// tag: &apos;img&apos;,
		/// src: &apos;http://www.example.com/example.jpg&apos;
		/// }
		/// }, {
		/// xtype: &apos;box&apos;,
		/// autoEl: {
		/// tag: &apos;blockquote&apos;,
		/// html: &apos;autoEl is cool!&apos;
		/// }
		/// }, {
		/// xtype: &apos;container&apos;,
		/// autoEl: &apos;ul&apos;,
		/// cls: &apos;ux-unordered-list&apos;,
		/// items: {
		/// xtype: &apos;box&apos;,
		/// autoEl: &apos;li&apos;,
		/// html: &apos;First list item&apos;
		/// }
		/// }
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;A tag name or {@link Ext.DomHelper DomHelper} spec used to create the {@link #getEl Element} which will
		/// encapsulate this Component.&lt;/p&gt;
		/// &lt;p&gt;You do not normally need to specify this. For the base classes {@link Ext.Component}, {@link Ext.BoxComponent},
		/// and {@link Ext.Container}, this defaults to &lt;b&gt;&lt;tt&gt;&apos;div&apos;&lt;/tt&gt;&lt;/b&gt;. The more complex Ext classes use a more complex
		/// DOM structure created by their own onRender methods.&lt;/p&gt;
		/// &lt;p&gt;This is intended to allow the developer to create application-specific utility Components encapsulated by
		/// different DOM elements. Example usage:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// {
		/// xtype: &apos;box&apos;,
		/// autoEl: {
		/// tag: &apos;img&apos;,
		/// src: &apos;http://www.example.com/example.jpg&apos;
		/// }
		/// }, {
		/// xtype: &apos;box&apos;,
		/// autoEl: {
		/// tag: &apos;blockquote&apos;,
		/// html: &apos;autoEl is cool!&apos;
		/// }
		/// }, {
		/// xtype: &apos;container&apos;,
		/// autoEl: &apos;ul&apos;,
		/// cls: &apos;ux-unordered-list&apos;,
		/// items: {
		/// xtype: &apos;box&apos;,
		/// autoEl: &apos;li&apos;,
		/// html: &apos;First list item&apos;
		/// }
		/// }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("autoEl")]
		public object AutoEl;
		
		/// <summary>CSS class added to the component when it is disabled (defaults to &apos;x-item-disabled&apos;).</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("disabledClass")]
		public string DisabledClass;
		
		/// <summary>Whether the component can move the Dom node when rendering (defaults to true).</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("allowDomMove")]
		public bool AllowDomMove;
		
		/// <summary>
		/// True if the component should check for hidden classes (e.g. &apos;x-hidden&apos; or &apos;x-hide-display&apos;) and remove
		/// them on render (defaults to false).
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("autoShow")]
		public bool AutoShow;
		
		/// <summary>
		/// How this component should be hidden. Supported values are &apos;visibility&apos;
		/// (css visibility), &apos;offsets&apos; (negative offset position) and &apos;display&apos;
		/// (css display).
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;How this component should be hidden. Supported values are &lt;tt&gt;&apos;visibility&apos;&lt;/tt&gt;
		/// (css visibility), &lt;tt&gt;&apos;offsets&apos;&lt;/tt&gt; (negative offset position) and &lt;tt&gt;&apos;display&apos;&lt;/tt&gt;
		/// (css display).&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: the default of &lt;tt&gt;&apos;display&apos;&lt;/tt&gt; is generally preferred
		/// since items are automatically laid out when they are first shown (no sizing
		/// is done while hidden).&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("hideMode")]
		public string HideMode;
		
		/// <summary>
		/// True to hide and show the component&apos;s container when hide/show is called on the component, false to hide
		/// and show the component itself (defaults to false). For example, this can be used as a shortcut for a hide
		/// button on a window by setting hide:true on the button when adding it to its parent container.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("hideParent")]
		public bool HideParent;
		
		/// <summary>
		/// Optional. Specify an existing HTML element, or the id of an existing HTML element to use as the content
		/// for this component.   Description :
		/// This config option is used to take an existing HTML element and place it in the layout element
		/// of a new component (it simply moves the specified DOM element after the Component is rendered to use as the content.   Notes :
		/// The specified HTML element is appended to the layout element of the component after any configured
		/// {@link #html HTML} has been inserted, and so the document will not contain this element at the time the {@link #render} event is fired.  The specified HTML element used will not participate in any {@link Ext.Container#layout layout}
		/// scheme that the Component may use. It is just HTML. Layouts operate on child {@link Ext.Container#items items}.  Add either the x-hidden or the x-hide-display CSS class to
		/// prevent a brief flicker of the content before it is rendered to the panel.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Optional. Specify an existing HTML element, or the &lt;code&gt;id&lt;/code&gt; of an existing HTML element to use as the content
		/// for this component.&lt;/p&gt;
		/// &lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;Description&lt;/b&gt; :
		/// &lt;div class=&quot;sub-desc&quot;&gt;This config option is used to take an existing HTML element and place it in the layout element
		/// of a new component (it simply moves the specified DOM element &lt;i&gt;after the Component is rendered&lt;/i&gt; to use as the content.&lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;Notes&lt;/b&gt; :
		/// &lt;div class=&quot;sub-desc&quot;&gt;The specified HTML element is appended to the layout element of the component &lt;i&gt;after any configured
		/// {@link #html HTML} has been inserted&lt;/i&gt;, and so the document will not contain this element at the time the {@link #render} event is fired.&lt;/div&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;The specified HTML element used will not participate in any &lt;code&gt;&lt;b&gt;{@link Ext.Container#layout layout}&lt;/b&gt;&lt;/code&gt;
		/// scheme that the Component may use. It is just HTML. Layouts operate on child &lt;code&gt;&lt;b&gt;{@link Ext.Container#items items}&lt;/b&gt;&lt;/code&gt;.&lt;/div&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;Add either the &lt;code&gt;x-hidden&lt;/code&gt; or the &lt;code&gt;x-hide-display&lt;/code&gt; CSS class to
		/// prevent a brief flicker of the content before it is rendered to the panel.&lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("contentEl")]
		public string ContentEl;
		
		/// <summary>
		/// An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the layout element
		/// content (defaults to &apos;&apos;). The HTML content is added after the component is rendered,
		/// so the document will not contain this HTML at the time the {@link #render} event is fired.
		/// This content is inserted into the body before any configured {@link #contentEl} is appended.
		/// </summary>
		/// <htmlSummary>
		/// An HTML fragment, or a {@link Ext.DomHelper DomHelper} specification to use as the layout element
		/// content (defaults to &apos;&apos;). The HTML content is added after the component is rendered,
		/// so the document will not contain this HTML at the time the {@link #render} event is fired.
		/// This content is inserted into the body &lt;i&gt;before&lt;/i&gt; any configured {@link #contentEl} is appended.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("html")]
		public ext.auto.System_String_Or_System_Object Html;
		
		/// <summary>
		/// An  ,  
		/// or an array of strings to form an Ext.XTemplate.
		/// Used in conjunction with the {@link #data} and
		/// {@link #tplWriteMode} configurations.
		/// </summary>
		/// <htmlSummary>
		/// An &lt;bold&gt;{@link Ext.Template}&lt;/bold&gt;, &lt;bold&gt;{@link Ext.XTemplate}&lt;/bold&gt;
		/// or an array of strings to form an Ext.XTemplate.
		/// Used in conjunction with the &lt;code&gt;{@link #data}&lt;/code&gt; and
		/// &lt;code&gt;{@link #tplWriteMode}&lt;/code&gt; configurations.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("tpl")]
		public object Tpl;
		
		/// <summary>
		/// The Ext.(X)Template method to use when
		/// updating the content area of the Component. Defaults to &apos;overwrite&apos;
		/// (see {@link Ext.XTemplate#overwrite}).
		/// </summary>
		/// <htmlSummary>
		/// The Ext.(X)Template method to use when
		/// updating the content area of the Component. Defaults to &lt;tt&gt;&apos;overwrite&apos;&lt;/tt&gt;
		/// (see &lt;code&gt;{@link Ext.XTemplate#overwrite}&lt;/code&gt;).
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("tplWriteMode")]
		public string TplWriteMode;
		
		/// <summary>
		/// The initial set of data to apply to the {@link #tpl} to
		/// update the content area of the Component.
		/// </summary>
		/// <htmlSummary>
		/// The initial set of data to apply to the &lt;code&gt;{@link #tpl}&lt;/code&gt; to
		/// update the content area of the Component.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("data")]
		public object Data;
		
		/// <summary>
		/// An array of events that, when fired, should be bubbled to any parent container.
		/// See {@link Ext.util.Observable#enableBubble}.
		/// Defaults to [].
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An array of events that, when fired, should be bubbled to any parent container.
		/// See {@link Ext.util.Observable#enableBubble}.
		/// Defaults to &lt;tt&gt;[]&lt;/tt&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("bubbleEvents")]
		public System.Array BubbleEvents;
		
		/// <summary>
		/// A path specification, relative to the Component&apos;s {@link #ownerCt}
		/// specifying into which ancestor Container to place a named reference to this Component.  The ancestor axis can be traversed by using &apos;/&apos; characters in the path.
		/// For example, to put a reference to a Toolbar Button into the Panel which owns the Toolbar:  
		/// var myGrid = new Ext.grid.EditorGridPanel({
		/// title: &apos;My EditorGridPanel&apos;,
		/// store: myStore,
		/// colModel: myColModel,
		/// tbar: [{
		/// text: &apos;Save&apos;,
		/// handler: saveChanges,
		/// disabled: true,
		/// ref: &apos;../saveButton&apos;
		/// }],
		/// listeners: {
		/// afteredit: function() {
		/// // The button reference is in the GridPanel
		/// myGrid.saveButton.enable();
		/// }
		/// }
		/// });
		///  In the code above, if the ref had been &apos;saveButton&apos;
		/// the reference would have been placed into the Toolbar. Each &apos;/&apos; in the ref
		/// moves up one level from the Component&apos;s {@link #ownerCt}.  Also see the {@link #added} and {@link #removed} events.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;A path specification, relative to the Component&apos;s &lt;code&gt;{@link #ownerCt}&lt;/code&gt;
		/// specifying into which ancestor Container to place a named reference to this Component.&lt;/p&gt;
		/// &lt;p&gt;The ancestor axis can be traversed by using &apos;/&apos; characters in the path.
		/// For example, to put a reference to a Toolbar Button into &lt;i&gt;the Panel which owns the Toolbar&lt;/i&gt;:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// var myGrid = new Ext.grid.EditorGridPanel({
		/// title: &apos;My EditorGridPanel&apos;,
		/// store: myStore,
		/// colModel: myColModel,
		/// tbar: [{
		/// text: &apos;Save&apos;,
		/// handler: saveChanges,
		/// disabled: true,
		/// ref: &apos;../saveButton&apos;
		/// }],
		/// listeners: {
		/// afteredit: function() {
		/// // The button reference is in the GridPanel
		/// myGrid.saveButton.enable();
		/// }
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;In the code above, if the &lt;code&gt;ref&lt;/code&gt; had been &lt;code&gt;&apos;saveButton&apos;&lt;/code&gt;
		/// the reference would have been placed into the Toolbar. Each &apos;/&apos; in the &lt;code&gt;ref&lt;/code&gt;
		/// moves up one level from the Component&apos;s &lt;code&gt;{@link #ownerCt}&lt;/code&gt;.&lt;/p&gt;
		/// &lt;p&gt;Also see the &lt;code&gt;{@link #added}&lt;/code&gt; and &lt;code&gt;{@link #removed}&lt;/code&gt; events.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("ref")]
		public string Ref;
		#endregion
		
		#region Properties
		/// <summary>This Component&apos;s initial configuration specification. Read-only.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("initialConfig")]
		[IntrinsicProperty()]
		public object InitialConfig
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>
		/// The {@link Ext.Element} which encapsulates this Component. Read-only.  This will usually be a &amp;lt;DIV&gt; element created by the class&apos;s onRender method, but
		/// that may be overridden using the {@link #autoEl} config.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;The {@link Ext.Element} which encapsulates this Component. Read-only.&lt;/p&gt;
		/// &lt;p&gt;This will &lt;i&gt;usually&lt;/i&gt; be a &amp;lt;DIV&gt; element created by the class&apos;s onRender method, but
		/// that may be overridden using the &lt;code&gt;{@link #autoEl}&lt;/code&gt; config.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: this element will not be available until this Component has been rendered.&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;To add listeners for &lt;b&gt;DOM events&lt;/b&gt; to this Component (as opposed to listeners
		/// for this Component&apos;s own Observable events), see the {@link Ext.util.Observable#listeners listeners}
		/// config for a suggestion, or use a render listener directly:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// new Ext.Panel({
		/// title: &apos;The Clickable Panel&apos;,
		/// listeners: {
		/// render: function(p) {
		/// // Append the Panel to the click handler&amp;#39;s argument list.
		/// p.getEl().on(&apos;click&apos;, handlePanelClick.createDelegate(null, [p], true));
		/// },
		/// single: true // Remove the listener after first invocation
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;See also &lt;tt&gt;{@link #getEl getEl}&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("el")]
		[IntrinsicProperty()]
		public ext.Element El
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>
		/// This Component&apos;s owner {@link Ext.Container Container} (defaults to undefined, and is set automatically when
		/// this Component is added to a Container). Read-only.
		/// Note: to access items within the Container see {@link #itemId}.
		/// </summary>
		/// <htmlSummary>
		/// This Component&apos;s owner {@link Ext.Container Container} (defaults to undefined, and is set automatically when
		/// this Component is added to a Container). Read-only.
		/// &lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: to access items within the Container see &lt;tt&gt;{@link #itemId}&lt;/tt&gt;.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("ownerCt")]
		[IntrinsicProperty()]
		public ext.Container OwnerCt
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>True if this component is hidden. Read-only.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("hidden")]
		[IntrinsicProperty()]
		public bool HiddenProperty
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>True if this component is disabled. Read-only.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("disabled")]
		[IntrinsicProperty()]
		public bool DisabledProperty
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>True if this component has been rendered. Read-only.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("rendered")]
		[IntrinsicProperty()]
		public bool Rendered
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>
		/// The ancestor Container into which the {@link #ref} reference was inserted if this Component
		/// is a child of a Container, and has been configured with a ref.
		/// </summary>
		/// <htmlSummary>
		/// The ancestor Container into which the {@link #ref} reference was inserted if this Component
		/// is a child of a Container, and has been configured with a &lt;code&gt;ref&lt;/code&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("refOwner")]
		[IntrinsicProperty()]
		public ext.Container RefOwner
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>Adds a CSS class to the component&apos;s underlying element.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="cls">The CSS class name to add</param>
		/// <returns>this</returns>
		[ScriptName("addClass")]
		public ext.Component AddClass(string cls)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes a CSS class from the component&apos;s underlying element.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="cls">The CSS class name to remove</param>
		/// <returns>this</returns>
		[ScriptName("removeClass")]
		public ext.Component RemoveClass(string cls)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Destroys this component by purging any event listeners, removing the component&apos;s element from the DOM,
		/// removing the component from its {@link Ext.Container} (if applicable) and unregistering it from
		/// {@link Ext.ComponentMgr}. Destruction is generally handled automatically by the framework and this method
		/// should usually not need to be called directly.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("destroy")]
		public void DestroyMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the {@link Ext.Element} which encapsulates this Component.  This will usually be a &amp;lt;DIV&gt; element created by the class&apos;s onRender method, but
		/// that may be overridden using the {@link #autoEl} config.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Returns the {@link Ext.Element} which encapsulates this Component.&lt;/p&gt;
		/// &lt;p&gt;This will &lt;i&gt;usually&lt;/i&gt; be a &amp;lt;DIV&gt; element created by the class&apos;s onRender method, but
		/// that may be overridden using the {@link #autoEl} config.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Note&lt;/b&gt;: this element will not be available until this Component has been rendered.&lt;/p&gt;&lt;br&gt;
		/// &lt;p&gt;To add listeners for &lt;b&gt;DOM events&lt;/b&gt; to this Component (as opposed to listeners
		/// for this Component&apos;s own Observable events), see the {@link #listeners} config for a suggestion,
		/// or use a render listener directly:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// new Ext.Panel({
		/// title: &apos;The Clickable Panel&apos;,
		/// listeners: {
		/// render: function(p) {
		/// // Append the Panel to the click handler&amp;#39;s argument list.
		/// p.getEl().on(&apos;click&apos;, handlePanelClick.createDelegate(null, [p], true));
		/// },
		/// single: true // Remove the listener after first invocation
		/// }
		/// });
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>The Element which encapsulates this Component.</returns>
		[ScriptName("getEl")]
		public ext.Element GetEl()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the id of this component or automatically generates and
		/// returns an id if an id is not defined yet: 
		/// &apos;ext-comp-&apos; + (++Ext.Component.AUTO_ID)
		/// </summary>
		/// <htmlSummary>
		/// Returns the &lt;code&gt;id&lt;/code&gt; of this component or automatically generates and
		/// returns an &lt;code&gt;id&lt;/code&gt; if an &lt;code&gt;id&lt;/code&gt; is not defined yet:&lt;pre&gt;&lt;code&gt;
		/// &apos;ext-comp-&apos; + (++Ext.Component.AUTO_ID)
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>id</returns>
		[ScriptName("getId")]
		public string GetId()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the {@link #itemId} of this component. If an
		/// {@link #itemId} was not assigned through configuration the
		/// id is returned using {@link #getId}.
		/// </summary>
		/// <htmlSummary>
		/// Returns the &lt;code&gt;{@link #itemId}&lt;/code&gt; of this component. If an
		/// &lt;code&gt;{@link #itemId}&lt;/code&gt; was not assigned through configuration the
		/// &lt;code&gt;id&lt;/code&gt; is returned using &lt;code&gt;{@link #getId}&lt;/code&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("getItemId")]
		public string GetItemId()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Disable this component and fire the &apos;disable&apos; event.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>this</returns>
		[ScriptName("disable")]
		public ext.Component DisableMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Enable this component and fire the &apos;enable&apos; event.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>this</returns>
		[ScriptName("enable")]
		public ext.Component EnableMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience function for setting disabled/enabled by boolean.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="disabled"></param>
		/// <returns>this</returns>
		[ScriptName("setDisabled")]
		public ext.Component SetDisabled(bool disabled)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Show this component. Listen to the &apos;{@link #beforeshow}&apos; event and return
		/// false to cancel showing the component. Fires the &apos;{@link #show}&apos;
		/// event after showing the component.
		/// </summary>
		/// <htmlSummary>
		/// Show this component. Listen to the &apos;{@link #beforeshow}&apos; event and return
		/// &lt;tt&gt;false&lt;/tt&gt; to cancel showing the component. Fires the &apos;{@link #show}&apos;
		/// event after showing the component.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Component ShowMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Hide this component. Listen to the &apos;{@link #beforehide}&apos; event and return
		/// false to cancel hiding the component. Fires the &apos;{@link #hide}&apos;
		/// event after hiding the component. Note this method is called internally if
		/// the component is configured to be {@link #hidden}.
		/// </summary>
		/// <htmlSummary>
		/// Hide this component. Listen to the &apos;{@link #beforehide}&apos; event and return
		/// &lt;tt&gt;false&lt;/tt&gt; to cancel hiding the component. Fires the &apos;{@link #hide}&apos;
		/// event after hiding the component. Note this method is called internally if
		/// the component is configured to be &lt;code&gt;{@link #hidden}&lt;/code&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Component HideMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Convenience function to hide or show this component by boolean.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="visible">True to show, false to hide</param>
		/// <returns>this</returns>
		[ScriptName("setVisible")]
		public ext.Component SetVisible(bool visible)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns true if this component is visible.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>True if this component is visible, false otherwise.</returns>
		[ScriptName("isVisible")]
		public bool IsVisible()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Clone the current component using the original config values passed into this instance by default.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="overrides">
		/// A new config containing any properties to override in the cloned version.
		/// An id property can be passed on this object, otherwise one will be generated to avoid duplicates.
		/// </param>
		/// <returns>clone The cloned copy of this component</returns>
		[ScriptName("cloneConfig")]
		public ext.Component CloneConfig(object overrides)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Gets the xtype for this component as registered with {@link Ext.ComponentMgr}. For a list of all
		/// available xtypes, see the {@link Ext.Component} header. Example usage:
		/// 
		/// var t = new Ext.form.TextField();
		/// alert(t.getXType()); // alerts &apos;textfield&apos;
		/// </summary>
		/// <htmlSummary>
		/// Gets the xtype for this component as registered with {@link Ext.ComponentMgr}. For a list of all
		/// available xtypes, see the {@link Ext.Component} header. Example usage:
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// alert(t.getXType()); // alerts &apos;textfield&apos;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>The xtype</returns>
		[ScriptName("getXType")]
		public string GetXType()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns this Component&apos;s xtype hierarchy as a slash-delimited string. For a list of all
		/// available xtypes, see the {@link Ext.Component} header.  If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.  Example usage:  
		/// var t = new Ext.form.TextField();
		/// alert(t.getXTypes()); // alerts &apos;component/box/field/textfield&apos;
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Returns this Component&apos;s xtype hierarchy as a slash-delimited string. For a list of all
		/// available xtypes, see the {@link Ext.Component} header.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// alert(t.getXTypes()); // alerts &apos;component/box/field/textfield&apos;
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>The xtype hierarchy string</returns>
		[ScriptName("getXTypes")]
		public string GetXTypes()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Find a container above this component at any level by a custom function. If the passed function returns
		/// true, the container will be returned.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="fn">The custom function to call with the arguments (container, this component).</param>
		/// <returns>The first Container for which the custom function returns true</returns>
		[ScriptName("findParentBy")]
		public ext.Container FindParentBy(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the next component in the owning container</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("nextSibling")]
		public ext.Component NextSibling()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the previous component in the owning container</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("previousSibling")]
		public ext.Component PreviousSibling()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Provides the link for Observable&apos;s fireEvent method to bubble up the ownership hierarchy.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>the Container which owns this Component.</returns>
		[ScriptName("getBubbleTarget")]
		public ext.Container GetBubbleTarget()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		/// <param name="position">
		/// The element ID or DOM node index within the container &lt;b&gt;before&lt;/b&gt;
		/// which this component will be inserted (defaults to appending to the end of the container)
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(ext.Element container, string position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		/// <param name="position">
		/// The element ID or DOM node index within the container &lt;b&gt;before&lt;/b&gt;
		/// which this component will be inserted (defaults to appending to the end of the container)
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(ext.Element container, System.Number position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		/// <param name="position">
		/// The element ID or DOM node index within the container &lt;b&gt;before&lt;/b&gt;
		/// which this component will be inserted (defaults to appending to the end of the container)
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(System.Html.Element container, string position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		/// <param name="position">
		/// The element ID or DOM node index within the container &lt;b&gt;before&lt;/b&gt;
		/// which this component will be inserted (defaults to appending to the end of the container)
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(System.Html.Element container, System.Number position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		/// <param name="position">
		/// The element ID or DOM node index within the container &lt;b&gt;before&lt;/b&gt;
		/// which this component will be inserted (defaults to appending to the end of the container)
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(string container, string position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		/// <param name="position">
		/// The element ID or DOM node index within the container &lt;b&gt;before&lt;/b&gt;
		/// which this component will be inserted (defaults to appending to the end of the container)
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(string container, System.Number position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(ext.Element container)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(System.Html.Element container)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="container">
		/// The element this Component should be
		/// rendered into. If it is being created from existing markup, this should be omitted.
		/// </param>
		[ScriptName("render")]
		public void RenderMethod(string container)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Render this Component into the passed HTML element.  If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.  A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.  Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.  If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.  When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the...
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Render this Component into the passed HTML element.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If you are using a {@link Ext.Container Container} object to house this Component, then
		/// do not use the render method.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;A Container&apos;s child Components are rendered by that Container&apos;s
		/// {@link Ext.Container#layout layout} manager when the Container is first rendered.&lt;/p&gt;
		/// &lt;p&gt;Certain layout managers allow dynamic addition of child components. Those that do
		/// include {@link Ext.layout.CardLayout}, {@link Ext.layout.AnchorLayout},
		/// {@link Ext.layout.FormLayout}, {@link Ext.layout.TableLayout}.&lt;/p&gt;
		/// &lt;p&gt;If the Container is already rendered when a new child Component is added, you may need to call
		/// the Container&apos;s {@link Ext.Container#doLayout doLayout} to refresh the view which causes any
		/// unrendered child Components to be rendered. This is required so that you can add multiple
		/// child components if needed while only refreshing the layout once.&lt;/p&gt;
		/// &lt;p&gt;When creating complex UIs, it is important to remember that sizing and positioning
		/// of child items is the responsibility of the Container&apos;s {@link Ext.Container#layout layout} manager.
		/// If you expect child items to be sized in response to user interactions, you must
		/// configure the Container with a layout manager which creates and manages the type of layout you
		/// have in mind.&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;Omitting the Container&apos;s {@link Ext.Container#layout layout} config means that a basic
		/// layout manager is used which does nothing but render child components sequentially into the
		/// Container. No sizing or positioning will be performed in this situation.&lt;/b&gt;&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("render")]
		public void RenderMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Update the content area of a component.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="htmlOrData">
		/// If this component has been configured with a template via the tpl config
		/// then it will use this argument as data to populate the template.
		/// If this component was not configured with a template, the components
		/// content area will be updated via Ext.Element update
		/// </param>
		/// <param name="loadScripts">(optional) Only legitimate when using the html configuration. Defaults to false</param>
		/// <param name="callback">(optional) Only legitimate when using the html configuration. Callback to execute when scripts have finished loading</param>
		[ScriptName("update")]
		public void Update(object htmlOrData, bool loadScripts, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Update the content area of a component.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="htmlOrData">
		/// If this component has been configured with a template via the tpl config
		/// then it will use this argument as data to populate the template.
		/// If this component was not configured with a template, the components
		/// content area will be updated via Ext.Element update
		/// </param>
		/// <param name="loadScripts">(optional) Only legitimate when using the html configuration. Defaults to false</param>
		[ScriptName("update")]
		public void Update(object htmlOrData, bool loadScripts)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Update the content area of a component.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="htmlOrData">
		/// If this component has been configured with a template via the tpl config
		/// then it will use this argument as data to populate the template.
		/// If this component was not configured with a template, the components
		/// content area will be updated via Ext.Element update
		/// </param>
		[ScriptName("update")]
		public void Update(object htmlOrData)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Apply this component to existing markup that is valid. With this function, no call to render() is required.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="el"></param>
		[ScriptName("applyToMarkup")]
		public void ApplyToMarkup(string el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Apply this component to existing markup that is valid. With this function, no call to render() is required.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="el"></param>
		[ScriptName("applyToMarkup")]
		public void ApplyToMarkup(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Try to focus this component.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="selectText">If applicable, true to also select the text in this component</param>
		/// <param name="delay">Delay the focus this number of milliseconds (true for 10 milliseconds)</param>
		/// <returns>this</returns>
		[ScriptName("focus")]
		public ext.Component Focus(bool selectText, bool delay)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Try to focus this component.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="selectText">If applicable, true to also select the text in this component</param>
		/// <param name="delay">Delay the focus this number of milliseconds (true for 10 milliseconds)</param>
		/// <returns>this</returns>
		[ScriptName("focus")]
		public ext.Component Focus(bool selectText, System.Number delay)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Try to focus this component.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="selectText">If applicable, true to also select the text in this component</param>
		/// <returns>this</returns>
		[ScriptName("focus")]
		public ext.Component Focus(bool selectText)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Try to focus this component.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <returns>this</returns>
		[ScriptName("focus")]
		public ext.Component Focus()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).  If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.  For a list of all available xtypes, see the {@link Ext.Component} header.  Example usage:  
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;For a list of all available xtypes, see the {@link Ext.Component} header.&lt;/p&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// <c>
		/// var c = new Ext.Component();
		/// console.log(c.isXType(c));
		/// console.log(c.isXType(Ext.Component));
		/// </c>&lt;/pre&gt;
		/// </param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>True if this component descends from the specified xtype, false otherwise.</returns>
		[ScriptName("isXType")]
		public bool IsXType(string xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).  If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.  For a list of all available xtypes, see the {@link Ext.Component} header.  Example usage:  
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;For a list of all available xtypes, see the {@link Ext.Component} header.&lt;/p&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// <c>
		/// var c = new Ext.Component();
		/// console.log(c.isXType(c));
		/// console.log(c.isXType(Ext.Component));
		/// </c>&lt;/pre&gt;
		/// </param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>True if this component descends from the specified xtype, false otherwise.</returns>
		[ScriptName("isXType")]
		public bool IsXType(ext.Component xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).  If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.  For a list of all available xtypes, see the {@link Ext.Component} header.  Example usage:  
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;For a list of all available xtypes, see the {@link Ext.Component} header.&lt;/p&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// <c>
		/// var c = new Ext.Component();
		/// console.log(c.isXType(c));
		/// console.log(c.isXType(Ext.Component));
		/// </c>&lt;/pre&gt;
		/// </param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>True if this component descends from the specified xtype, false otherwise.</returns>
		[ScriptName("isXType")]
		public bool IsXType(System.Type xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).  If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.  For a list of all available xtypes, see the {@link Ext.Component} header.  Example usage:  
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;For a list of all available xtypes, see the {@link Ext.Component} header.&lt;/p&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// <c>
		/// var c = new Ext.Component();
		/// console.log(c.isXType(c));
		/// console.log(c.isXType(Ext.Component));
		/// </c>&lt;/pre&gt;
		/// </param>
		/// <returns>True if this component descends from the specified xtype, false otherwise.</returns>
		[ScriptName("isXType")]
		public bool IsXType(string xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).  If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.  For a list of all available xtypes, see the {@link Ext.Component} header.  Example usage:  
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;For a list of all available xtypes, see the {@link Ext.Component} header.&lt;/p&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// <c>
		/// var c = new Ext.Component();
		/// console.log(c.isXType(c));
		/// console.log(c.isXType(Ext.Component));
		/// </c>&lt;/pre&gt;
		/// </param>
		/// <returns>True if this component descends from the specified xtype, false otherwise.</returns>
		[ScriptName("isXType")]
		public bool IsXType(ext.Component xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).  If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.  For a list of all available xtypes, see the {@link Ext.Component} header.  Example usage:  
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Tests whether or not this Component is of a specific xtype. This can test whether this Component is descended
		/// from the xtype (default) or whether it is directly of the xtype specified (shallow = true).&lt;/p&gt;
		/// &lt;p&gt;&lt;b&gt;If using your own subclasses, be aware that a Component must register its own xtype
		/// to participate in determination of inherited xtypes.&lt;/b&gt;&lt;/p&gt;
		/// &lt;p&gt;For a list of all available xtypes, see the {@link Ext.Component} header.&lt;/p&gt;
		/// &lt;p&gt;Example usage:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// var t = new Ext.form.TextField();
		/// var isText = t.isXType(&apos;textfield&apos;); // true
		/// var isBoxSubclass = t.isXType(&apos;box&apos;); // true, descended from BoxComponent
		/// var isBoxInstance = t.isXType(&apos;box&apos;, true); // false, not a direct BoxComponent instance
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// <c>
		/// var c = new Ext.Component();
		/// console.log(c.isXType(c));
		/// console.log(c.isXType(Ext.Component));
		/// </c>&lt;/pre&gt;
		/// </param>
		/// <returns>True if this component descends from the specified xtype, false otherwise.</returns>
		[ScriptName("isXType")]
		public bool IsXType(System.Type xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a container above this component at any level by xtype or class</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// </param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>The first Container which matches the given xtype or class</returns>
		[ScriptName("findParentByType")]
		public ext.Container FindParentByType(string xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a container above this component at any level by xtype or class</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// </param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>The first Container which matches the given xtype or class</returns>
		[ScriptName("findParentByType")]
		public ext.Container FindParentByType(ext.Component xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a container above this component at any level by xtype or class</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// </param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>The first Container which matches the given xtype or class</returns>
		[ScriptName("findParentByType")]
		public ext.Container FindParentByType(System.Type xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a container above this component at any level by xtype or class</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// </param>
		/// <returns>The first Container which matches the given xtype or class</returns>
		[ScriptName("findParentByType")]
		public ext.Container FindParentByType(string xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a container above this component at any level by xtype or class</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// </param>
		/// <returns>The first Container which matches the given xtype or class</returns>
		[ScriptName("findParentByType")]
		public ext.Container FindParentByType(ext.Component xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a container above this component at any level by xtype or class</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="xtype">
		/// The xtype to check for this Component. Note that the the component can either be an instance
		/// or a component class:
		/// </param>
		/// <returns>The first Container which matches the given xtype or class</returns>
		[ScriptName("findParentByType")]
		public ext.Container FindParentByType(System.Type xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (this) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the bubble is stopped.
		/// </summary>
		/// <htmlSummary>
		/// Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (&lt;i&gt;this&lt;/i&gt;) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the bubble is stopped.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope of the function (defaults to current node)</param>
		/// <param name="args">The args to call the function with (default to passing the current component)</param>
		/// <returns>this</returns>
		[ScriptName("bubble")]
		public ext.Component Bubble(System.Delegate fn, object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (this) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the bubble is stopped.
		/// </summary>
		/// <htmlSummary>
		/// Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (&lt;i&gt;this&lt;/i&gt;) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the bubble is stopped.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope of the function (defaults to current node)</param>
		/// <returns>this</returns>
		[ScriptName("bubble")]
		public ext.Component Bubble(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (this) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the bubble is stopped.
		/// </summary>
		/// <htmlSummary>
		/// Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (&lt;i&gt;this&lt;/i&gt;) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the bubble is stopped.
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <returns>this</returns>
		[ScriptName("bubble")]
		public ext.Component Bubble(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		///  or:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		/// &lt;/pre&gt;&lt;/code&gt;
		/// &lt;p&gt;or:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// &lt;/pre&gt;&lt;/code&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item to which to add a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		/// <param name="opt">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the {@link Ext.util.Observable#addListener addListener} options.
		/// </param>
		[ScriptName("mon")]
		public void Mon(ext.util.Observable item, object ename, System.Delegate fn, object scope, object opt)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		///  or:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		/// &lt;/pre&gt;&lt;/code&gt;
		/// &lt;p&gt;or:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// &lt;/pre&gt;&lt;/code&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item to which to add a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		/// <param name="opt">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the {@link Ext.util.Observable#addListener addListener} options.
		/// </param>
		[ScriptName("mon")]
		public void Mon(ext.util.Observable item, string ename, System.Delegate fn, object scope, object opt)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		///  or:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		/// &lt;/pre&gt;&lt;/code&gt;
		/// &lt;p&gt;or:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// &lt;/pre&gt;&lt;/code&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item to which to add a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		/// <param name="opt">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the {@link Ext.util.Observable#addListener addListener} options.
		/// </param>
		[ScriptName("mon")]
		public void Mon(ext.Element item, object ename, System.Delegate fn, object scope, object opt)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		///  or:  
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Adds listeners to any Observable object (or Elements) which are automatically removed when this Component
		/// is destroyed. Usage:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), &apos;selectionchange&apos;, handleSelectionChange, null, {buffer: 50});
		/// &lt;/pre&gt;&lt;/code&gt;
		/// &lt;p&gt;or:&lt;/p&gt;&lt;code&gt;&lt;pre&gt;
		/// myGridPanel.mon(myGridPanel.getSelectionModel(), {
		/// selectionchange: handleSelectionChange,
		/// buffer: 50
		/// });
		/// &lt;/pre&gt;&lt;/code&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item to which to add a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		/// <param name="opt">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the {@link Ext.util.Observable#addListener addListener} options.
		/// </param>
		[ScriptName("mon")]
		public void Mon(ext.Element item, string ename, System.Delegate fn, object scope, object opt)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes listeners that were added by the {@link #mon} method.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item from which to remove a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		[ScriptName("mun")]
		public void Mun(ext.util.Observable item, object ename, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes listeners that were added by the {@link #mon} method.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item from which to remove a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		[ScriptName("mun")]
		public void Mun(ext.util.Observable item, string ename, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes listeners that were added by the {@link #mon} method.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item from which to remove a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		[ScriptName("mun")]
		public void Mun(ext.Element item, object ename, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes listeners that were added by the {@link #mon} method.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		/// <param name="item">The item from which to remove a listener/listeners.</param>
		/// <param name="ename">The event name, or an object containing event name properties.</param>
		/// <param name="fn">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the handler function.
		/// </param>
		/// <param name="scope">
		/// Optional. If the <c>ename</c> parameter was an event name, this
		/// is the scope (<c>this</c> reference) in which the handler function is executed.
		/// </param>
		[ScriptName("mun")]
		public void Mun(ext.Element item, string ename, System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
		
		#region Events
		/// <summary>Fires when a component is added to an Ext.Container</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("added")]
		public event ext.auto.Delegate_ext_Component_And_ext_Container_And_System_Number Added;
		
		/// <summary>Fires after the component is disabled.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("disable")]
		public event ext.auto.Delegate_ext_Component Disable;
		
		/// <summary>Fires after the component is enabled.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("enable")]
		public event ext.auto.Delegate_ext_Component Enable;
		
		/// <summary>
		/// Fires before the component is shown by calling the {@link #show} method.
		/// Return false from an event handler to stop the show.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforeshow")]
		public event ext.auto.Delegate_ext_Component Beforeshow;
		
		/// <summary>Fires after the component is shown when calling the {@link #show} method.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("show")]
		public event ext.auto.Delegate_ext_Component Show;
		
		/// <summary>
		/// Fires before the component is hidden by calling the {@link #hide} method.
		/// Return false from an event handler to stop the hide.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforehide")]
		public event ext.auto.Delegate_ext_Component Beforehide;
		
		/// <summary>
		/// Fires after the component is hidden.
		/// Fires after the component is hidden when calling the {@link #hide} method.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("hide")]
		public event ext.auto.Delegate_ext_Component Hide;
		
		/// <summary>Fires when a component is removed from an Ext.Container</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("removed")]
		public event ext.auto.Delegate_ext_Component_And_ext_Container Removed;
		
		/// <summary>
		/// Fires before the component is {@link #rendered}. Return false from an
		/// event handler to stop the {@link #render}.
		/// </summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforerender")]
		public event ext.auto.Delegate_ext_Component Beforerender;
		
		/// <summary>Fires after the component markup is {@link #rendered}.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("render")]
		public event ext.auto.Delegate_ext_Component Render;
		
		/// <summary>
		/// Fires after the component rendering is finished.  The afterrender event is fired after this Component has been {@link #rendered}, been postprocesed
		/// by any afterRender method defined for the Component, and, if {@link #stateful}, after state
		/// has been restored.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Fires after the component rendering is finished.&lt;/p&gt;
		/// &lt;p&gt;The afterrender event is fired after this Component has been {@link #rendered}, been postprocesed
		/// by any afterRender method defined for the Component, and, if {@link #stateful}, after state
		/// has been restored.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("afterrender")]
		public event ext.auto.Delegate_ext_Component Afterrender;
		
		/// <summary>Fires before the component is {@link #destroy}ed. Return false from an event handler to stop the {@link #destroy}.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforedestroy")]
		public event ext.auto.Delegate_ext_Component Beforedestroy;
		
		/// <summary>Fires after the component is {@link #destroy}ed.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("destroy")]
		public event ext.auto.Delegate_ext_Component Destroy;
		
		/// <summary>Fires before the state of the component is restored. Return false from an event handler to stop the restore.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforestaterestore")]
		public event ext.auto.Delegate_ext_Component_And_System_Object Beforestaterestore;
		
		/// <summary>Fires after the state of the component is restored.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("staterestore")]
		public event ext.auto.Delegate_ext_Component_And_System_Object Staterestore;
		
		/// <summary>Fires before the state of the component is saved to the configured state provider. Return false to stop the save.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("beforestatesave")]
		public event ext.auto.Delegate_ext_Component_And_System_Object Beforestatesave;
		
		/// <summary>Fires after the state of the component is saved to the configured state provider.</summary>
		/// <definedin>src\widgets\Component.js</definedin>
		[ScriptName("statesave")]
		public event ext.auto.Delegate_ext_Component_And_System_Object Statesave;
		#endregion
	}
}
